\documentclass[12pt,a4paper,titlepage,oneside]{article}
\usepackage[top=2.5cm, bottom=2cm, left=2.5cm, right=1cm]{geometry} 
%\usepackage{graphicx}
%\usepackage{amsmath}
%\usepackage{gensymb}
%\usepackage{multirow}
% Font, accents
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{times}                % Otros: palatino, bookman
% Interactive index
\usepackage{hyperref}
% Spanish titles
\usepackage[spanish]{babel}
% Attached files
\usepackage{attachfile}
\attachfilesetup{
  icon = Paperclip
}
% Fix curly verbatim apostrophes
\usepackage{upquote,textcomp}
% Make lists without bullets
\renewenvironment{itemize}{
 \begin{list}{}{
  \setlength{\leftmargin}{1.5em}
 }
}{
 \end{list}
}
% Sections in clear pages
\usepackage{titlesec}
\newcommand{\sectionbreak}{\clearpage}
% Document properties
\title{Informe de Teoría de Lenguajes: Common Lisp}
\author{Federico Churca Torrusio <fchurca{@}fi.uba.ar>\\
Federico Farina <federicofarina22{@}gmail.com> \\
Docentes a cargo: Rosita Wachenchauzer, Martín Franco}
\date{\today}
\hypersetup{
  colorlinks = true,
  urlcolor = red,
  pdflang = es,
  pdfauthor = {Federico Churca Torrusio, Federico Farina},
  pdfproducer = {Federico Churca Torrusio},
  pdfcreator = Texmaker,
  pdftitle = {Informe de Teoría de Lenguajes: Common Lisp},
  pdfsubject = {},
  pdfpagemode = UseNone
}
\begin{document}
 \maketitle
  \setcounter{page}{1}
  \pagenumbering{roman}
  \addcontentsline{toc}{section}{Índice}
  \tableofcontents
% \newpage
% \listoffigures
% \listoftables
%\newpage{}
%\pagenumbering{arabic}
%\setcounter{page}{1}

\section*{Resumen}
\addcontentsline{toc}{section}{Resumen}
El propósito de éste informe es realizar un análisis teórico de las características básicas del lenguaje Common Lisp y proveer una introducción al mismo, dando algunos ejemplos puntuales.

Al realizarse éste informe se utilizaron las implementaciones de Common Lisp \href{http://www.sbcl.org/}{SBCL}\footnote{http://www.sbcl.org/} y \href{http://www.clisp.org/}{CLisp}\footnote{http://www.clisp.org/}. Aún así, como el lenguaje Common Lisp está especificado como un estándar, usualmente no es necesario atenerse a una implementación en particular.

Para profundizar sobre el lenguaje y ver temas que fueron dejados de lado debido al alcance del informe se pueden consultar entre otros el libro \href{http://www.gigamonkeys.com/book/}{Practical Common Lisp}\footnote{http://www.gigamonkeys.com/book/} de Peter Seibel o el \href{http://www.lispworks.com/documentation/HyperSpec/Front/}{Common Lisp HyperSpec}\footnote{http://www.lispworks.com/documentation/HyperSpec/Front}.

\newpage{}
\pagenumbering{arabic}
\setcounter{page}{1}

\section{Reseña histórica}
El lenguaje de programación Lisp fue diseñado en 1958 por John McCarthy en el MIT para procesamiento de datos simbólicos. Es el segundo lenguaje de programación de alto nivel más antiguo en uso corriente, precedido por pocos años por FORTRAN. Uno de los roles que cumplía era procesamiento de listas; de ahí su nombre, LISt Processing language. Tomó aspectos como procesamiento de listas y recursión de IPL (Information Processing Language), desarrollado en 1956.

En los orígenes de Lisp las computadoras tenían capacidades muy limitadas, por lo cual se desarrollaron máquinas dedicadas e intérpretes y compiladores optimizados. En 1962 se desarrolló el primer compilador completo para Lisp, que estaba además escrito en Lisp. Fue así el primer lenguaje con autohosting. También con ese compilador se introdujo el modelo de compilación incremental, donde conviven funciones interpretadas y compiladas libremente.

Como a principios de los '70 Lisp era un sistema difícil de implementar con el hardware y las técnicas de compilación existentes, se crearon Lisp Machines, computadoras diseñadas para optimizar la ejecución de código Lisp, pero el desarrollo de técnicas de recolección de basura lo suficientemente avanzadas como para poder correr Lisp en computadoras de propósito general hizo obsoletas a las Lisp Machines. Las implementaciones de dialectos actuales como Common Lisp, luego de más de medio siglo de desarrollo, compiten con lenguajes más recientes y de más bajo nivel como C en términos de rendimiento.

Originalmente pensado para resolver problemas matemáticos, fue evolucionando a lo largo de las siguientes tres décadas, siendo usado para aplicaciones que van desde demostración automatizada de algoritmos e inteligencia artificial hasta visión artificial y simulación de campos de batalla.

A fines de los '70, después de una sobreestimación de los desarrollos de inteligencia artificial, y a fines de los '80, con el fin de la guerra fría, hubieron dos AI winters (inviernos de inteligencia artificial) que ralentizaron el desarrollo de Lisp. Algunos sistemas, como las Lisp Machines, cayeron en desuso, mientras que otros como Symbolics Genera sobrevivieron.

Para principios de los '80, había una multitud de sistemas y dialectos de Lisp, por lo cual se decidió estandarizar los dialectos más usados y diseñar un lenguaje nuevo. Éste esfuerzo comenzó en 1981, se publicó un resumen en 1984, en 1986 estaban disponibles las primeras implementaciones, y en 1994 se publicó el estándar ANSI para Common Lisp.

Desde entonces, se siguió desarrollando sobre Common Lisp, agregándose al estándar en 1999 CLOS (Common Lisp Object System) proveyendo soporte para programación orientada a objetos, y el sistema de condiciones (excepciones), apareciendo también entornos ricos con interfaces gráficas, multithreading, sockets TCP/IP y más.

\section{Características básicas}
Common Lisp es un lenguaje multiparadigma de propósitos generales. Soporta una combinación de paradigmas de programación como imperativo y funcional en forma nativa, y programación orientada a objetos por medio de CLOS. Siendo un lenguaje extensible, se le puede agregar soporte para diferentes paradigmas sin necesidad de reescribir intérpretes ni compiladores; un ejemplo de esto es la librería AspectL, que agrega soporte para programación orientada a aspectos.

Es un lenguaje dinámico ya que se puede extender el programa añadiendo código, objetos, definiciones y modificando el sistema de tipos durante la ejecución del mismo. Soporta procesamiento de macros en tiempo de ejecución y continuación de condiciones (excepciones), entre otros aspectos dinámicos. Soportando tanto lamda-expressions como \textbf{EVAL}, y siendo un lenguaje homoicónico, ya que el código fuente de un programa está expresado en términos de estructuras de datos nativos de Common Lisp como listas y símbolos, es un entorno propicio para la metaprogramación.

Usa tipado dinámico y fuerte. Por un lado, mientras cada variable no tiene un tipo de datos asociado, cada valor sí lo tiene. Ésto permite hacer uso de late binding y dynamic dispatch en formas mucho más simples que en lenguajes con tipado estático. Por otro lado, se puede especificar en un método qué tipos de parámetros esperar y fallar si no se cumplen esas restricciones, garantizando que los resultados obtenidos sean correctos. También tiene soporte para casteo de tipos y annotations, con lo que se puede sugerir al compilador cómo implementar determinados tipos.

\section{REPL, introducción a la sintaxis}
Common Lisp es generalmente implementado como un entorno basado en una imagen, con un sistema similar al de Smalltalk. Aquí se tiene disponible generalmente un compilador y un debugger además del resto del runtime, que suelen ser usados por ejemplo al definir funciones o cuando una condición de error no es manejada. El runtime incluye frecuentemente un garbage collector y un memory manager que hacen a la alocación y dealocación de memoria automática y eficiente, y el programador generalmente no necesita interactuar con ellos.

Aunque las implementaciones de Common Lisp pueden ser ejecutadas en forma interactiva, el código termina siendo completamente compilado antes de ser ejecutado. Así, aunque es un lenguaje dinámico, no es un lenguaje interpretado. Pueden darse casos de aplicaciones embebidas, por ejemplo en robótica o astronáutica, donde todo el código necesario ya está incluído en la imágen y puede dispensarse del compilador, y se escribió un exception handler dedicado y puede dispensarse del debugger también, caso en el que el ambiente es una imágen de código nativo como suelen ser los ejecutables en otros lenguajes.

Muchas implementaciones de Common Lisp proveen un mecanismo llamado REPL, o Read - Eval - Print Loop. Éste toma sentencias, las evalúa, e imprime el resultado.

\begin{verbatim}
-> 10 
10 
\end{verbatim}

El primer 10 es uno que ingresó el usuario. El reader lee el texto \texttt{10} y crea un objeto que representa al número 10. Éste objeto es un objeto que se autoevalúa, lo que significa que cuando es entregado al evaluator el resultado es el mismo objeto. Éste valor es entregado al printer, el cual imprime \texttt{10}.

\begin{verbatim}
-> (+ 2 3) 
5 
\end{verbatim}

Cualquier cosa entre paréntesis es una lista; en éste caso es una lista de tres elementos, el símbolo \textbf{+} y los numeros 2 y 3. Lisp, en general, evalúa las listas tratando el primer elemento como una función y el resto de los elementos como argumentos. En éste caso, el simbolo \textbf{+} hace referencia a una función que suma. 2 y 3 se evalúan a sí mismos y son pasados a la función de adición, la cual retorna 5. El valor es pasado al printer, el cual imprime el valor.

Ningún informe esta completo sin un hello world. Es trivialmente fácil hacer al REPL imprimir \texttt{"Hello, world!"}.

\begin{verbatim}
-> "Hello, world!" 
"Hello, world!"
\end{verbatim}

Ésto funciona porque los strings, como los números, tienen una sintaxis que el reader entiende y son self-evaluating objects. Lisp lee las dobles comillas e instancia un objeto string en la memoria que, cuando es evaluado, se evalúa a si mismo, y luego es impreso por el printer en la misma sintaxis literal. Las dobles comillas no son parte del string object en memoria, son sólo la sintaxis que le dice al reader que lea un string. El printer las imprime cuando se imprime la cadena ya que intenta imprimir objetos en la misma sintaxis que el reader comprende. 

Otra característica de Lisp es que cada sentencia retorna el último resultado que se evaluó. Por eso, no se ven tantos retornos explícitos como en otros lenguajes. En los ejemplos anteriores se evaluaba un sólo valor, y ése mismo valor era retornado.

\subsection{Salida estándar}
Se puede tomar un paso hacia un verdadero programa escribiendo algo de código que como efecto secundario (no es un efecto a partir de un valor devuelto) imprime la cadena \texttt{Hello, world!} en la salida estándar. 
Common Lisp provee varias maneras de hacerlo, pero las más flexible es la función \textbf{FORMAT}. \textbf{FORMAT} toma un número variable de argumentos, pero los dos únicos requeridos son el stream adonde mandar la salida y el string a mandar, en forma similar a \textbf{fprintf()} en C. Si se pasa \textbf{T} como primer argumento, \textbf{FORMAT} manda la salida a la salida estándar.

\begin{verbatim}
-> (format t "Hello, world!") 
Hello, world! 
NIL 
\end{verbatim}

Algo a notar sobre el resultado de la expresión es el \textbf{NIL} abajo de la salida. Éste \textbf{NIL} es el resultado de evaluar \textbf{FORMAT}. \textbf{FORMAT} es más útil por su efecto secundario, imprimir a la salida estándar en este caso, que por su valor de retorno, pero todas las expresiones en Lisp evaluan a algún resultado. 

\subsection{Declaración de funciones}
Las funciones son uno de los bloques de construcción de programas básicos de Lisp y pueden ser definidos con la expresión \textbf{DEFUN}:

\begin{verbatim}
-> (defun hello-world () 
  (format t "Hello, world!")) 
HELLO-WORLD 
\end{verbatim}

\textbf{DEFUN} devuelve una referencia al objeto función creado. Ésto se verá más adelante en una sección sobre funciones.

En un nivel, ésta expresión, como las otras hasta ahora vistas, es sólo otra expresión a ser leída, evaluada e impresa por el REPL. El valor de retorno en éste caso es el nombre de la función definida, pero como la función \textbf{FORMAT}, ésta expresión es más interesante por sus efectos que por sus valores de retorno. 
La mayoría de los efectos secundarios son invisibles; cuando ésta expresion es evaluada, una  nueva función que no toma argumentos y con el cuerpo \texttt{(format t "Hello, world!")} es creada y se le da el nombre \textbf{HELLO-WORLD}. 

Una vez definida la función, se la puede invocar: 

\begin{verbatim}
-> (hello-world) 
Hello, world!
NIL
\end{verbatim}

Se puede ver que la salida es la misma que cuando se evalua la función \textbf{FORMAT} directamente. Las funciones en Common Lisp automáticamente retornan el valor de la última expresión que evaluaron.

\subsection{Comentarios}
Los comentarios precedidos por un punto y coma (;), y siempre son por el resto de la línea. Pueden ir en cualquier lugar de la línea, sólos o después de un poco de código. También se tienen comentarios inline entre las secuencias \#{}| y |\#{} pero no son tan usados. Como convención, se pone un comentario al principio de cada archivo con una descripción de qué hace, quién lo escribió, y un historial de edición; luego se pueden poner subencabezados con cuatro puntos y comas (;;;;), tres puntos y comas (;;;) para los comentarios antes de una función, clase, variable o macro (aunque bastante de esa información puede ponerse en el docstring), dos puntos y comas antes de alguna expresión particular que se quiere aclarar, y un punto y coma (;) al final de renglones particulares.

\subsection{Cargando cambios}
Siendo Common Lisp un lenguaje dinámico, se puede cargar código en tiempo de ejecución. Para eso, se puede usar la función \textbf{LOAD} para cargar archivos fuente de texto, que son compilados al cargarse, o archivos compilados, pero en éste informe no se tratarán éstos últimos.
\begin{verbatim}
->(load "nreinas.lisp")
;; Loading file nreinas.lisp ...
;; Loaded file nreinas.lisp
T
\end{verbatim}
El retorno de \textbf{T} indica que el archivo se cargó correctamente. Si lo que esta definido en ese archivo ya estaba definido en el entorno, se sobreescribe y actualiza. Una vez que se cargó un archivo se puede proceder a ejecutar código definido ahí:
\begin{verbatim}
->(print-valid-boards 4)

Tablero: (3 1 4 2)
_|_|#|_|
#|_|_|_|
_|_|_|#|
_|#|_|_|

Tablero: (2 4 1 3)
_|#|_|_|
_|_|_|#|
#|_|_|_|
_|_|#|_|


2 Tableros válidos de tamaño 4
((3 1 4 2) (2 4 1 3))
\end{verbatim}

\section{Sintaxis, S-expressions}
Common Lisp usa S-expressions para denotar tanto el código como la estructura de datos. Los elementos básicos de las S-expressions son las listas y los átomos. Las listas están limitadas por paréntesis y cualquier número de espacios separando elementos. Por átomos se refiere a todo lo demás; números, cadenas y nombres.

Dos valores muy importantes a destacar son \textbf{NIL} y \textbf{T}. \textbf{NIL} puede significar una de tres cosas; el símbolo con el nombre \textbf{NIL}, la lista vacía o un valor booleano falso. De hecho, para el reader es indistinto leer \texttt{()} o \texttt{nil} ya que guarda a ambos como \textbf{NIL}. Como convención, se usa \texttt{()} cuando se quiere usar una lista vacía, y \texttt{nil} cuando se quiere el valor booleano falso. Cuando se espera un valor de verdad, cualquier valor diferente a \textbf{NIL} va a ser considerado verdadero, pero como convención se usa el símbolo estándar \textbf{T} para representar el valor booleano verdadero. Tanto \textbf{NIL} como \textbf{T} son símbolos autoevaluantes.

\subsection{Átomos}

\subsubsection{Números}

Cualquier secuencia de digitos, posiblemente precedidos por un signo, conteniendo un punto decimal(.), una barra(/),o terminando con un exponente, es un número válido.

Algunos ejemplos:
\begin{verbatim}
123       ; El entero 123 
3/7       ; La fraccion tres soptimos 
1.0       ; El numero 1.0 en punto flotante con precision simple
1.0e0     ; Otra manera de escribir el mismo numero
1.0d0     ; El numero 1.0 en punto flotante con doble precision
1.0e-4    ; El numero 0.0001 en punto flotante
1.0d-4    ; El numero 0.0001 en punto flotante con doble precision
+42       ; El numero positivo 42
-42       ; El numero negativo -42
-1/4      ; La fraccion -1/4
-2/8      ; Otra forma de escribir -1/4
246/2     ; Otra forma de escribir el entero 123
\end{verbatim}

Lisp también soporta números complejos.
\begin{verbatim}
\#C(1 2)  ; 1 + 2i
\end{verbatim}

\subsubsection{Strings}
Los strings se representan entre dobles comillas. Con una barra invertida se puede escapar el caracter siguiente, haciendo que éste sea incluído en la cadena sin importar qué sea. Los únicos dos caracteres que necesitan ser incluídos de ésta manera son las dobles comillas y la propia barra invertida.

Algunos ejemplos:
\begin{verbatim}
"foo"     ; La cadena que contiene los caracteres f, o, y o
"fo\o"    ; La misma cadena
"fo\\o"   ; La cadena que contine los caracteres f, o, \, y o
"fo\"o"   ; La cadena que contiene los caracteres f, o, " y o
\end{verbatim}

\subsubsection{Nombres}
Los nombres que se que se usan en los programas de Lisp tales como \textbf{FORMAT} estan representados por objetos llamados símbolos.El reader no sabe nada acerca de cómo un nombre se va a usar, si es el nombre de una variable, funcion o algo más. Él sólo lee una secuencia de caracteres y construye un objeto para representar el nombre.

Los caracteres siguientes no pueden ser incluidos en los nombres:
", ', /, \textbackslash{}, whitespace tal como espacios o tabulaciones, (, ), y  ` .

Cuando se lee el nombre el reader convierte el nombre a su equivalente en mayúsculas. Por lo tanto, \textbf{foo}, \textbf{Foo}, y \textbf{FOO} son tratados como el mismo simbolo: \textbf{FOO}. Luego de ésta conversión, el reader busca en una tabla de símbolos llamada package un símbolo existente con el mismo nombre. Si no lo encuentra, éste crea un símbolo nuevo y lo agrega a la tabla. Si no, devuelve el símbolo que ya esta en la tabla.

\subsection{Listas como S-expressions}
Aunque se va a tratar más específicamente sobre listas, por ahora es importante entender cómo combinar números, strings y símbolos con paréntesis, delimitando listas para construir expresiones representando árboles de objetos arbitrarios.
\begin{verbatim}
()             ; Lista vacia
(1 2 3)        ; Lista que contiene 1, 2 y 3
("foo" "bar")  ; Lista con dos strings
(x 1 "foo")    ; Lista con un simbolo, un nombre y un string
(+ (* 2 3) 4)  ; Lista con el simbolo +, una lista, y un numero
;; Lista que contiene dos simbolos, la lista vacia y otra lista,
;;  que contiene dos simbolos y un string.
(defun hello-world () (format t "hello, world"))
\end{verbatim}

No todas las S-expressions son código Lisp válido; sólo lo son átomos o listas que tenga como primer elemento un símbolo.

\section{Estructuras de control}
Lisp provee varios mecanismos para controlar el flujo de ejecución de un programa. Algunos están implementados como macros basados en otros, pero algunos de ellos son operadores especiales. Uno de ellos es \textbf{PROGN}, que toma varias sentencias y las ejecuta, devolviendo el valor retornado por la última sentencia. Si no recibe ninguna sentencia, devuelve \textbf{NIL}:
\begin{verbatim}
(progn
  (do-some-stuff)
  (do-more-stuff))
\end{verbatim}

\subsection{Evaluación condicional}
Lisp fue uno de los primeros lenguajes en tener construcciones de lenguajes dedicadas a la evaluación condicional en vez de simples saltos condicionados. En Common Lisp, muchos de esos mecanismos como \textbf{WHEN}, \textbf{UNLESS}, y \textbf{COND} pueden construirse en base a \textbf{IF} y \textbf{PROGN}. El operador especial \textbf{IF} toma su primer parámetro, evalúa su segundo parámetro si el primero es distinto de \textbf{NIL}, o evalúa el tercero si el primer parámetro da \textbf{NIL}:
\begin{verbatim}
(if (hungry-p)
  (eat)
  (watch movie))
\end{verbatim}

Cuando sólo se quiere ejecutar algo cuando un valor es verdadero, se puede usar \textbf{WHEN}; si la evaluación de su primer resultado da diferente a \textbf{NIL} evalúa el resto de los parámetros, y si no devuelve \textbf{NIL}. No necesita encerrar el cuerpo a ejecutar con un \textbf{PROGN} como debería hacerse en \textbf{IF} si se quiere ejecutar más de una expresión:
\begin{verbatim}
(when (hungry-p)
  (order pizza)
  (eat))
\end{verbatim}

\textbf{UNLESS} vendría a ser el complemento de \textbf{WHEN}; evalúa el resto de sus parámetros si el primero es \textbf{NIL}. Si la evaluación de su primer parámetro devuelve algo diferente a \textbf{NIL}, \textbf{UNLESS} devuelve \textbf{NIL}:
\begin{verbatim}
(unless (raining-p)
  (wear shoes)
  (leave hat))
\end{verbatim}

\textbf{COND} es un mecanismo de ejecución condicional más flexible; recibe varias listas de expresiones, y para cada una, si la primera es válida, ejecuta el resto de la lista para ese caso y no revisa ningún caso más. Si no puede correr ningún caso, devuelve \textbf{NIL}. Puede usarse \textbf{T} como último valor para ejecutar código por defecto si no se cumple ninguno de los otros casos:
\begin{verbatim}
(cond
  (thirsty-p (drink))
  (hungry-p (cook) (eat))
  (bored-p (watch (get-random-movie))
  (t (setf bored-p t)))
\end{verbatim}

\subsection{\textbf{AND}, \textbf{OR}, \textbf{NOT}}
Para controlar el flujo de un programa, suele ser necesario combinar varios valores para realizar una decisión. \textbf{NOT} está implementado como una función que devuelve \textbf{T} si su parámetro es distinto a \textbf{NIL} y \textbf{NIL} si su parámetro es \textbf{NIL}, sirviendo de negación booleana. \textbf{AND} y \textbf{OR}, por otro lado, son macros, definidas de forma tal que evalúan sus argumentos de forma tal que puedan cortocircuitarse. \textbf{AND} evalúa su lista de argumentos hasta encontrar uno que devielva \textbf{NIL} o se le acaben. Si evalúa todos sus argumentos devuelve el valor que retornó el último, y si no devuelve \textbf{NIL}. Por otro lado, \textbf{OR} deja de evaluar sus argumentos si alguno devuelve un valor que no sea \textbf{NIL}, y devuelve ese valor en ese caso. Si todos sus argumentos devuelven \textbf{NIL}, \textbf{OR} devuelve \textbf{NIL}:
\begin{verbatim}
(not nil)             ; T
(not (= 1 1)          ; NIL
(and (= 1 2) (= 3 3)) ; NIL
(or (= 1 2) (= 3 3))  ; T
\end{verbatim}

\subsection{Ciclos}
Lisp provee de varios mecanismos para ejecutar ciclos, algunos de ellos bastante flexibles, implementados como macros estándar. Uno de ellos es la macro \textbf{DO} que, aunque es muy poderosa, es complicada para muchos casos simples; por eso, Lisp provee otras dos macros, \textbf{DOLIST} y \textbf{DOTIMES} que, aunque son menos flexibles que \textbf{DO}, simplifican ciertos casos particulares bastante frecuentes.

\textbf{DOLISP} trata uno por uno los elementos de una lista, ejecutando el cuerpo del ciclo con una variable con los diferentes ítems de la lista, y devuelve \textbf{NIL} si llega a su fin. Se puede escapar de un ciclo con \textbf{RETURN}, retornando el último valor evaluado.
\begin{verbatim}
(dolist (variable list)
	(some-stuff variable)
	(more-stuff))
\end{verbatim}

\textbf{DOTIMES} se porta en forma similar con respecto al ciclo sólo que, en vez de tomar una lista, toma un número y hace variar la variable de iteración entre 0 y ese número:
\begin{verbatim}
(dolist (variable max)
	(mysterious-stuff)
	(foo (* 8 variable)))
\end{verbatim}

Como se puede usar cualquier expresión como cuerpo de ciclo, se pueden anidar.
\begin{verbatim}
(dotimes (x 4)
  (dotimes (y 4)
    (format t "~3d " (* (1+ x) (1+ y))))
  (format t "~%"))
\end{verbatim}

Aunque \textbf{DOTIMES} y \textbf{DOLISP} son fáciles de usar, no son suficientemente flexibles como para cubrir todos los casos. \textbf{DO} permite iterar sobre cualquier cantidad de variables de forma arbitraria y dar una condición de corte también arbitraria. Recibe una lista de definiciones de variables, una lista con un form para la condición de corte y opcionalmente un form para el retorno, y opcionalmente expresiones a ejecutar, y cada definición de variable es una lista conteniendo el nombre local de la variable, su vlaor inicial, y opcionalmente un form con el nuevo valor de la variable después de cada iteración:
\begin{verbatim}
(do ((n 0 (1+ n))
     (cur 0 next)
     (next 1 (+ cur next)))
    ((= 10 n) cur)
    (format t "~%~4d: ~4d" (1+ n) next))
\end{verbatim}

\textbf{DO} es más general que \textbf{DOTIMES} y \textbf{DOLIST}, pero todavía es rígido con respecto a la sintaxis. La macro \textbf{LOOP} provee un mecanismo muy flexible para recorrer colecciones, acumular resultados en colecciones, maximizando, minimizando, contando, sumando, verificar condiciones de corte y ejecutar expresiones arbitrarias y varias otras más. Aunque explorar todas las posibilidades escapa el alcance de éste informe, se proveen algunos ejemplos a continuación:
\begin{verbatim}
(loop repeat 5 (format t "Hello!"))

(loop for i from 1 to 10 collecting i)

(loop
  for other-row in remaining
  for columns from 1
  never (captures-p current-row other-row columns))
\end{verbatim}

\subsection{Mecanismos de evaluación}

Common Lisp provee una manera de escribir expresiones que no van a ser evaluadas o que sólo se quieren evaluar parcialmente. Un backquote (\textbf{`}) antes de una expresión detiene la evaluación igual que el apóstrofe (\textbf{'}).

\begin{verbatim}
`( 1 2 3)            ; (1 2 3)
'( 1 2 3)            ; (1 2 3)
\end{verbatim}

La diferencia entre ambos es que en una expresión con backquote, cualquier expresión precedida por una coma (\textbf{,}) es evaluada:

\begin{verbatim}
`( 1 2 (+ 1 2))      ; (1 2 (+ 1 2))
`( 1 2 ,(+ 1 2))     ; (1 2 3)
\end{verbatim}

El símbolo arroba (\textbf{@}) empalma el valor de la siguiente expresión adjunta:

\begin{verbatim}
`( 1 2 ,@(list 3 4)) ; (1 2 3 4)
`(and ,@'(1 2))      ; (and 1 2)
\end{verbatim}

\section{Funciones}

Un aspecto muy importante de Common Lisp son las funciones. Éstas sirven para abstraer parte del comportamiento de un programa, no sólo desde el punto de vista procedural; como se verá mas ádelante, el sistema de objetos está también encarado desde el punto de vista funcional.

Para definir una función, se usa la macro \textbf{DEFUN}, la cual toma un nombre para la función, una lista de parámetros, opcionalmente un string de documentación, y las sentencias que va a ejecutar:
\begin{verbatim}
(defun foo-fun (param1 param2)
  "This is a function"
  (princ "Summing parameters")
  (+ param1 param2))
\end{verbatim}

\subsection{Parámetros}
Define las variables que van a hacer usadas para guardar los argumentos pasados a la funcion cuando es llamada, puede ser la lista vacía.  Lisp soporta funciones variádicas por medio de varios mecanismos que se verán a continuación.

\subsubsection{Parámetros opcionales}
Una función puede tener parámetros opcionales; éstos se especifican precedidos por el símbolo \textbf{\&{}optional}. El usuario puede omitir darles valores, caso en el cual toman valores por defecto. Si no se especifica uno, el valor por defecto es, por defecto, \textbf{NIL}:
\begin{verbatim}
(defun foo (a b &optional c d) (list a b c d))
(foo 1 2)            ; (1 2 NIL NIL)
(foo 1 2 3)          ; (1 2 3 NIL)
(foo 1 2 3 4 )       ; (1 2 3 4)
\end{verbatim}

Para darles valores por defecto a los parámetros opcionales, se pueden definir con listas; el primer elemento es el nombre del parámetro, y el segundo el valor por defecto. Éste puede referir a otros parámetros definidos:
\begin{verbatim}
(defun foo (a &optional (b 10))
  (princ (vector a b)))
(defun bar (a &optional (b a))
  (princ (list a b)))
\end{verbatim}

Aveces puede ser útil comprobar si se han pasado ciertos parámetros. En ese caso, se agrega a la lista de cada parámetro una variable donde se guarda \textbf{NIL} si se omitió y tomó su valor por defecto o \textbf{T} si fue provisto su valor al invocar la función:
\begin{verbatim}
(defun foo (a b &optional(c 3 c-supplied-p))
	(list a b c c-supplied-p))
\end{verbatim}

\begin{verbatim}
(foo 1 2)            ; (1 2 3 NIL)
(foo 1 2 3)	         ; (1 2 3 T)
(foo 1 2 4)          ; (1 2 4 T)
\end{verbatim}

\subsubsection{Rest Parameters}
En ocasiones se necesita tener un numero variable de parámetros en una función. Éstos pueden ser guardados como una lista en un parámetro especificado por el símbolo \textbf{\&{}rest}. Ésta es una forma de evitar tener que definir un parámetro opcional para cada parámetro posible, cuya cantidad máxima es como mínimo 50, y en implementaciones modernas entre 4096 y 536870911 parámetros.
\begin{verbatim}
(defun show-tail (&rest numbers)
  (print numbers) 
  (if (null numbers)
    0
    (rest numbers)))
\end{verbatim}

Los parámetros rest parameters son sólo una lista, por lo tanto se pueden controlar utilizando las operaciones normales de listas.

\subsubsection{Keyword Parameters}
Este tipo de parámetros no dependen de la posición en que sean pasados. Como los parámetros opcionales, pueden dejarse con valor por defecto \textbf{NIL}, o especificar un valor por defecto y una variable de predicado de provisión:
\begin{verbatim}
(defun foo (&key a (b t) (c nil c-supplied-p)) 
  (list a b c c-supplied-p))
\end{verbatim}

\begin{verbatim}
(foo :a 1)           ; (1 T NIL NIL)
(foo :b 1)           ; (NIL 1 NIL NIL)
(foo :c 0)           ; (NIL T 0 T)
\end{verbatim}

\subsection{Valores de retorno}
Todas las funciones hasta ahora  usaban el modo por defecto de devolver la ultima expresión que se evalúa como el valor de retorno. Para cambiar esta propiedad existe el operador especial \textbf{RETURN-FROM}, que sirve para devolver valores desde bloques nombrados y funciones (en realidad es lo mismo ya que \textbf{DEFUN} al definir una función encierra el cuerpo en un \textbf{BLOCK} con el mismo nombre que la función). Recibe como argumento el nombre del bloque o función del cual se quiere retornar y opcionalmente un valor. Como el nombre no se evalúa, no es necesario citarlo con \textbf{QUOTE} o \textbf{'}.

\begin{verbatim}
(return-from fname value)
\end{verbatim}

Que haya que indicar el nombre de la funcion es una restriccion, sin embargo no suele usarse mucho en Lisp ya que las expresiones (incluidas loops y condicionales) devuelven siempre un valor.

\subsection{Documentación}

Cuando la funcion es definida el string de documentación se asocia al nombre de la funcion y puede ser obtenido luego usando la funcion \textbf{DOCUMENTATION}. Recibe dos símbolos; uno con el nombre del objeto y otro con qué tipo de objeto se busca. Para buscar documentación de funciones se pasa como segundo argumento \textbf{'function}, y retorna el string de documentación asociado a ese objeto.
\begin{verbatim}
(defun foo ()
  "Foo function for returning nil"
  nil)
(documentation 'foo 'function)
\end{verbatim}

\subsection{Programación de alto orden}
Normalmente se llama a las funciones por nombre, pero ocasionalmente es conveniente usar las funciones como datos. Ésto permite escribir algoritmos genéricos que delegen detalles de implementación al programador, como por ejemplo escribir un algoritmo de ordenamiento que reciba por parámetro qué comparación usar al ordenar, o definir callback y hooks.

Ésto se debe a que en Common Lisp las funciones son simplemente otro tipo más de objetos, que están representados en memoria por una descripción de cómo invocarlo, opcionalmente un poco de documentación y, dependiendo de la implementación, bloques de código máquina o bytecode.

Para obtener el objeto asociado a una función se usa el operador \textbf{FUNCTION}. Como se suele usar frecuentemente, puede abreviarse con \textbf{\#'} como \textbf{QUOTE} puede abreviarse con \textbf{'}.

\begin{verbatim}
(defun square (a) (* a a))
(function square)
#<FUNCTION SQUARE> 
#'square
#<FUNCTION SQUARE> 
\end{verbatim}

Para invocar una función a través de su objeto se usan dos operadores, \textbf{FUNCALL} y \textbf{APPLY}. \textbf{FUNCALL} le pasa a la función especificada por su primer parámetro todos los otros. Suele usarse cuando se conocen los parámetros a pasarle a un objeto función.

\begin{verbatim}
(defun plot (fn min max step)
  (loop for i from min to max by step do
    (loop repeat (funcall fn i) do (format t "*"))
    (format t "~%")))
\end{verbatim}

Nótese que no se necesita usar \textbf{FUNCTION} para tomar el valor de \textbf{FN} ya que ya está pasado como objeto.

\begin{verbatim}
(plot #'square -2 2 1)
**** 
* 

* 
**** 
NIL
\end{verbatim}

\textbf{APPLY} suele usarse cuando se tienen listas de parámetros para pasarle a un objeto función. \textbf{APPLY} desarma los parámetros si son listas y se los pasa al primer parámetro. Así, si para el ejemplo anterior se tienen los parámetros en una lista, se puede hacer tanto:

\begin{verbatim}
(apply #'plot plot-data)    ; Si plot-data tiene (fn min max step)
\end{verbatim}

como:

\begin{verbatim}
(apply #'plot #'fun limits) ; Si limits tiene (min max step)
\end{verbatim}

\subsection{Lambda expressions – funciones anónimas}

A veces se tiene que pasar por parámetro una función pero se la usa una sola vez, y no se necesita guardar una función. Se pueden crear funciones anónimas con expresiones lambda.
\begin{verbatim}
#'(lambda (x) (+ 4 (- x) (* x x x))) 
#<FUNCTION (LAMBDA (X)) {AAD6DF5}>
\end{verbatim}

Luego para llamarla :

\begin{verbatim}
(funcall (lambda (x) (+ 4 (- x) (* x x x))) 4) 
64 
\end{verbatim}

Es legal también usar expresiones lambda donde se usarían nombres de funciones:

\begin{verbatim}
((lambda (x) (+ 4 (- x) (* x x x))) 4) 
64 
\end{verbatim}

Así, si sólo se va a usar una vez una expresión, en vez de crear una función dedicada y guardarla, se puede usar una expresión lambda equivalente:

\begin{verbatim}
(plot #'(lambda (x) (* 2 x)) 0 5 1)

** 
**** 
****** 
******** 
********** 
NIL 
\end{verbatim}

Las expresiones lambda pueden también usarse para hacer closures, funciones que capturan parte del entorno en el cual fueron creadas. Eso se ve más adelante.

\section{Variables} 
Como en otros lenguajes, las variables en  Common Lisp son lugares con nombre que pueden contener un valor. Cada variable no es de un determinado tipo como en Java o C; ésto quiere decir que no se debe especificar el tipo de objeto que cada variable puede almacenar. Entonces Common Lisp es dinámicamente tipado, lo que significa que los errores de tipos son detectados en tiempo de ejecución. Por otra parte, Common Lisp es fuertemente tipado en el sentido de que todos los errores de tipos son detectados; no hay forma de tratar a un objeto como una instancia de una clase que no es. Aún así, se puede deshabilitar el chequeo de tipos en regiones de código, en general con motivos de optimización.

Casi todos los valores en Common Lisp son referencias a objetos. Consecuentemente, asignar un valor nuevo a una variable cambia a qué objeto la variable se refiere, pero no tiene efecto en el objeto antes referenciado. De ésta forma, si la variable contiene una referencia a un objeto mutable, se puede usar para modificar el objeto, y la modificacion será visible a cualquier porción de código que tenga una referencia a ese objeto.

Como una optimización, ciertos tipos de objetos, tales como enteros por debajo de un cierto tamaño, pueden ser representados directamente en memoria donde otros objetos serían representados como un puntero al objeto actual. De todas formas, como los enteros son inmutables, no hay tanto problema de que haya múltiples copias del mismo objeto en diferentes variables.

\subsection{Variables Léxicas}

Por defecto, todos los binding forms en Common Lisp introducen variables con scope léxico. Las variables léxicas pueden ser referidas sólo por el código que está dentro del binding form. Éste tipo de variables tiene que ser familiar para cualquiera que haya programado en Java, C, Perl o Phyton ya que todos ellos proveen variables locales con scope léxico.
Un binding es la manifestación en tiempo de ejecución de una variable. Una sola variable puede tener múltiples bindings al mismo tiempo. Una forma de introducir nuevas variables es definir parametros en una función; cada vez que se llame a esa función, se crean nuevos bindings para almacenar los argumentos pasados a la función.

Por ejemplo, ésta función define 3 variables x, y, z  para almacenar sus argumentos:
\begin{verbatim}
(defun foo (x y z) (+ x y z))
\end{verbatim}

Como todas las variables en Common Lisp, los parámetros de una función guardan referencias a objetos. Entonces, se puede asignar un nuevo valor a un parámetro dentro del cuerpo de la funcion, y no afecta a los bindings creados por otra llamada a la misma función. Pero si el objeto que se pasa a la función es mutable y se cambia dentro del cuerpo, el cambio es visible en todas las variables que referencien al mismo objeto.

Otra forma de introducir nuevas variables es el operador \textbf{LET}. Cuando \textbf{LET} es evaluado, nuevos bindings son creados e inicializados antes que el body sea ejecutado. El scope de las variables introducidas con \textbf{LET} está delimitado desde la declaración de las variables hasta el fin del body de la instrucción. Ésta forma  de definir variables con \textbf{LET} es llamada binding form. Los binding forms se pueden declarar de la siguiente forma:
\begin{verbatim}
(let ((var1 val1) ... ) body)
\end{verbatim}

Una variante es el operador \textbf{LET*} con el que se puede hacer referencia a variables creadas previamente en la misma definición:
\begin{verbatim}
(let* ((x 10) (y (* 2 x)) z) body)
\end{verbatim}

Cada referencia a una variable se referirá al binding con el menor scope que la contenga:
\begin{verbatim}
(defun foo (x)							
  (format t "Parametro: ~a~%" x)   ;;  X es el argumento
  (let(x 2)							
    (format t "Let de afuera: ~a~%" x)  ;;X es 2
    (let (x 3)							
      (format t "Let de adentro: ~a~%" x))  ;;X es 3	
    (format t "Let de afuera: ~a~%" x))				
  (format t "Parametro: ~a~%" x))				
\end{verbatim}

\subsubsection{Pattern matching}
Se puede usar la macro \textbf{DESTRUCTURING-BIND} para introducir variables léxicas inicializadas de cierta forma muy útil, enlazándolas con distintas partes de una lista. Ésto se conoce en otros lenguajes como OZ como "pattern matching", aunque, a diferencia del mecanismo usado en OZ, un uso de \textbf{DESTRUCTURING-BIND} con una lista que no cumpla el patrón hace que se levante una condición de tipo \textbf{ERROR}; ésto se debe a que \textbf{DESTRUCTURING-BIND} está más pensado como herramienta para desarmar listas cuya estructura ya se conoce que como para verificar la estructura de una lista.

\textbf{DESTRUCTURING-BIND} recibe una lista de parámetros donde guardar las partes de la lista, la lista a analizar, y el código a ejecutar, pero la lista de parámetros es diferente a la de una función. No sólo pueden ser \textbf{\&{}optional}, \textbf{\&{}rest} o \textbf{\&{}key}, puede haber parámetros de tipo \textbf{\&{}whole} donde se guarda toda la lista; normalmente si se usan parámetros \textbf{\&{}whole} se usa uno sólo. Además, pueden haber parámetros de cualquier tipo en sublistas dentro de la lista de parámetros principal.

\begin{verbatim}
(destructuring-bind (&whole w x y z)
  (list 1 (list 21 22) 3)
  (list :x x :y y :z z :w w))
  ; (:X 1 :Y (21 22) :Z 3 :W (1 (21 22) 3))
(destructuring-bind (x (&whole yw y1 &optional y2 y3) &optional z)
  (list 1 (list 21 22) 3)
  (list :x x :yw yw :y1 y1 :y2 y2 :y3 y3 :z z))
  ; (:X 1 :YW (21 22) :Y1 21 :Y2 22 :Y3 NIL :Z 3)
(destructuring-bind (&key x (y 0) (z :b z-provided-p))
  (list :z 1 :x 3)
  (list :x x :y y :z z :z-provided-p z-provided-p))
  ; (:X 3 :Y 0 :Z 1 :Z-PROVIDED-P T)
\end{verbatim}

\subsubsection{Closures}
Con la combinacion del scope léxico y las funciones anidadas, se da origen a los \textbf{closures}:

\begin{verbatim}
(setf count
  (let ((contador 0))
    #'(lambda ()
      (setf contador (+ 1 contador)))))
\end{verbatim}

La referencia a count debería ser legal de acuerdo con las reglas del scope léxico; sin embargo, la función anónima conteniendo la referencia será devuelta como valor del \textbf{LET} y podrá ser invocada mediante \textbf{FUNCALL} por código que no  esta dentro del scope del \textbf{LET}. Éste ejemplo funcionará siempre y cuando contador sea una variable léxica. La función anónima es llamada \textit{closure} porque captura el binding creado por el \textbf{LET}.

\subsection{Variables dinámicas}
Las variables con scope léxico sirven para mantener el código entendible limitando el scope en el cual una misma variable tiene significado. Esta es la razón por la que los lenguajes modernos usan variables con scope léxico para variables locales. Pero algunas veces se necesitan variables globales, variables a las que uno pueda referirse desde cualquier lado en el programa. Mientras que es verdad que el uso indiscriminado de las variables globales crea un programa inentendible y desordenado hay usos realmente buenos de éstas. La version de Lisp de las variables globales, las variables dinámicas, son mas útiles y manejables. Lisp provee dos maneras de declarar variables globales, \textbf{DEFVAR} y \textbf{DEFPARAMETER}.

\textbf{DEFVAR} asegura que una variable exista, y si no existe o no tiene valor se le puede opcionalmende dar un valor. Si la variable ya tenía un valor y se le pasa un valor a \textbf{DEFVAR}, no hace nada:
\begin{verbatim}
(defvar *name* value "Documentacion")
\end{verbatim}

\textbf{DEFPARAMETER} le da un valor a una variable, creándola si no existe:
\begin{verbatim}
(defparameter *name* value "Documentacion")
\end{verbatim}

\subsection{Constantes}
Otra clase de variable es la contradictoria "variable constante". Todas las constantes son globales y son definidas con \textbf{DEFCONSTANT}.
\begin{verbatim}
(defconstant *name* value "Documentacion")
\end{verbatim}

Al igual que con \textbf{DEFVAR} y \textbf{DEFPARAMETER} , \textbf{DEFCONSTANT} tiene un efecto global en el nombre usado, pero a diferencia de las variables dinámicas, el nombre de una constante no puede ser usado como nombre de un parámetro de una función. No se pueden cambiar sus valores excepto redefiniendo la variable, lo cual no es aconsejable ya que no se puede estar seguro de que en algunos lados la constante tenga un valor más antiguo. Por lo tanto, es aconsejable usar constantes sólo en los casos que lo que la variable realmente sea una constante.

\subsection{Asignación}
Una vez que se tiene un binding, se pueden hacer dos cosas: obtener el valor actual y asignarle un nuevo valor. Como ya se mencionó, un símbolo se evalua al valor de la variable al que nombra; por lo tanto, se puede obtener el valor de una variable simplemente refiriendose a la variable. Para asignar un nuevo valor al binding, se puede usar el macro \textbf{SETF}:
\begin{verbatim}
(setf place valor)
\end{verbatim}

Como \textbf{SETF} es un macro, puede examinar la forma que tiene place y expandirlo en una cantidad apropiada de operaciones de bajo nivel para manipularlo. Cuando place es una variable, éste se expande en una llamada a un operador especial llamado \textbf{SETQ}, el cual, como operador especial, tiene acceso a los bindings léxicos y dinámicos. Una vez que termina, \textbf{SETF} retorna el valor recién asignado.

\begin{verbatim}
(setf x (setf y (random 10))) 
\end{verbatim}

\subsubsection{Asignación generalizada}
Los binding sobre variables, por supuesto, no son los únicos lugares que pueden almacenar valores. Common Lisp soporta estructras de datos compuestas tales como arrays, hash tables, y listas y tipos definidos por el usuario. Se debe notar que \textbf{SETF} puede asignar en cualquiér lugar un valor tal como es la asignación con el operador = o := en otros lenguajes:
\begin{verbatim}
(defparameter *h* (list :foo 1 :bar 2))
(setf (getf *h* :foo) 800) 
\end{verbatim}

\section{Colecciones}
Como la mayoría de los lenguajes de programación, Lisp provee tipos estándar que agrupan multiples valores en un objeto único. Lisp es, por supuesto, famoso por su estructura de datos lista, y la mayoría de los libros de Lisp hacen hincapié en ellas para explicar todas las colecciones. Sin embargo, ésto hace que algunos lectores lleguen a la conclusión errónea de que son el único tipo de colección disponible en Lisp. Y además la lista es una estructura de datos tan flexible que es posible usarla para hacer las cosas que en otros lenguajes son hechas por arrays y hash tables. Pero es un error enfocarse tanto en listas ya que en muchas situaciones otras estructuras de datos más apropiadas ya están implementadas.

\subsection{Vectores}
Los vectores son colecciones con índices enteros y vienen en dos tipos: vectores estáticos y vectores dinámicos .

Se puede hacer vectores estáticos conteniendo valores específicos con la función \textbf{VECTOR}, que toma cualquiér número de argumentos y devuelve un vector con esos argumentos como contenido.

\begin{verbatim}
(vector)     ; #()
(vector 1)   ; #(1)
(vector 1 2) ; #(1 2)
\end{verbatim}

La sintaxis \#{}(...) es la notación literal para los vectores usada por el reader y el printer.
Se puede usar \textbf{VECTOR} para incluir vectores literales en el código, pero se debe usar \textbf{MAKE-ARRAY} para crear vectores que se planea modificar:
\begin{verbatim}
(make-array value &rest)
\end{verbatim}

\textbf{MAKE-ARRAY} es más general que \textbf{VECTOR} en el sentido de que se pueden crear arrays de cualquier dimensión , estáticos y dinámicos. El único atributo obligatorio en \textbf{MAKE-ARRAY} es un número con el tamaño del array. También hay parámetros opcionales como \textbf{:initial-element}, el cual sirve para inicializar el vector:
\begin{verbatim}
(make-array 5 :initial-element nil)
; #(NIL NIL NIL NIL NIL)
\end{verbatim}

Un vector redimensionable lleva una cuenta sobre cuantos elementos tiene actualmente por medio de \textbf{:fill-pointer}, entonces la siguiente llamada crea un vector con lugar para 5 elementos, pero se ve vacío porque el fill-pointer es cero:
\begin{verbatim}
(make-array 5 :fill-pointer 0)
; #() 
\end{verbatim}

Para agregar un elemento al final de un vector redimensionable se puede usar \textbf{VECTOR-PUSH}, que agrega un elemento en la posición actual del fill-pointer y luego lo incrementa en uno, devuelvendo el índice donde el nuevo elemento ha sido insertado. De forma similar \textbf{VECTOR-POP}  devuelve el último elemento agregado y decrementa el fill-pointer en 1.

Sin embargo aún el vector anterior no es totalmente redimensionable; para que sí lo sea se debe usar \textbf{MAKE-ARRAY}. Para hacer vectores dinámicos se le puede pasar el parámetro \textbf{:adjustable}:

\begin{verbatim}
(make-array 5 :fill-pointer 0 :adjustable t)
; #()
\end{verbatim}

Ésta llamada crea un vector dinámico, el cual puede redimensionarse a medida que se necesite. 
Para agregar elementos a un vector dinámico se usa \textbf{VECTOR-PUSH-EXTEND}, que trabaja similarmente a \textbf{VECTOR-PUSH}, excepto que expande automáticamente el vector si se trata de agregar un elemento y el vector está lleno.

\subsection{Funciones de iteración sobre secuencias}
Common Lisp provee una gran librería de funciones para secuencias. Las funciones de secuencia permiten expresar ciertas operaciones tales como buscar o filtrar elementos específicos sin escribir loops explícitos
\begin{itemize}
\item \textbf{COUNT}\\
Recibe: Elemento y secuencia\\
Devuelve: Cantidad de apariciones del elemento en la secuencia
\item \textbf{FIND}\\
Recibe: Elemento y secuencia\\
Devuelve: Elemento o \textbf{NIL}
\item \textbf{POSITION}\\
Recibe: Elemento y secuencia\\
Devuelve: Índice en la secuencia o \textbf{NIL}
\item \textbf{REMOVE}\\
Recibe: Elemento y secuencia\\
Devuelve: Secuencia sin instancias del elemento
\item \textbf{SUBSTITUTE}\\
Recibe: Nuevo elemento, elemento, y secuencia\\
Devuelve: Secuencia con instancias del elemento reemplazadas
\end{itemize}

Ejemplos:
\begin{verbatim}
(count 1 #(1 2 1 2 3 1 2 3 4))        ; 3
(remove 1 #(1 2 1 2 3 1 2 3 4))       ; #(2 2 3 2 3 4)
(substitute #\x #\b "foobarbaz")      ; "fooxarxaz"
(find 1 #(1 2 1 2 3 1 2 3 4))         ; 1
(find 10 #(1 2 1 2 3 1 2 3 4))        ; NIL
(position 1 #(1 2 1 2 3 1 2 3 4))     ; 0
\end{verbatim}

\subsection{Ordenamiento y mezcla}
Las funciones \textbf{SORT} y \textbf{STABLE-SORT} proveen dos maneras de ordenar una secuencia. Las dos toman una secuencia y un método de dos parámetros y devuelven una versión ordenada de la secuencia.
\begin{verbatim}
(sort (vector "foo" "bar" "baz") #'string<)
; #("bar" "baz" "foo")
\end{verbatim}
La diferencia con \textbf{STABLE-SORT} es que este ultimo no reordena cualquier elemento que sea considerado equivalente por el precido mientras \textbf{SORT} garantiza solo que el resultado es ordenado y puede reordenar elementos equivalentes.

La función \textbf{MERGE} toma dos secuencias y un predicado y devuelve la secuencia que resulta de unir las dos secuencias anteriores. El primer argumento para \textbf{MERGE} debe ser un tipo describiendo el tipo de la secuencia producida:
\begin{verbatim}
(merge 'vector #(1 3 5) #(2 4 6) #'<) ; #(1 2 3 4 5 6)
(merge 'list #(1 3 5) #(2 4 6) #'<)   ; (1 2 3 4 5 6)
\end{verbatim}

\subsection{Hash-tables}
Otra colección de propósito general que provee Common Lisp es la hash-table. Mientras los vectores proveen una estructura indexada por enteros, las hash-tables permiten usar objetos arbitrarios como índices o claves. Cuando se agrega un valor a un hash-table, se guarda bajo una clave particular y luego se puede recuperar ese valor usando la misma clave para obtenerlo. También se puede asociar un nuevo valor con la misma clave para obtener los dos elementos. 

Sin argumentos, \textbf{MAKE-HASH-TABLE} crea una hash-table que considera dos claves equivalentes si son el mismo objeto de acuerdo con \textbf{EQL}.
\begin{verbatim}
(defparameter *h* (make-hash-table))
\end{verbatim}

Si se necesita que las claves matcheen de acuerdo a otro criterio se puede pasar como argumento \textbf{:test} cuyos posibles valores son \textbf{EQ}, \textbf{EQL}, \textbf{EQUAL} y \textbf{EQUALP}.

La función \textbf{GETHASH} provee acceso a los elementos del hash-table. \textbf{GETHASH} toma dos argumentos: una clave y un hash-table.
\begin{verbatim}
(gethash 'foo *h*) ; NIL
\end{verbatim}
\textbf{GETHASH} devuelve \textbf{NIL} si no hay ningún elemento asociado a la clave requerida.

\subsection{Iteraciones sobre Hashtables}
Common Lisp provee algunas maneras de iterar sobre las entradas de un hash-table. La manera más sencilla de hacerlo es mediante la función \textbf{MAPHASH}. \textbf{MAPHASH} toma una función de dos parámetros y una hash-table y invoca la función por cada par clave/valor en la tabla:
\begin{verbatim}
(maphash #'(lambda (k v) (format t "~a => ~a~%" k v)) *h*)
\end{verbatim}
Esta función imprimira cada par por la salida estándar.

Otra manera de iterar sobre una hash-table es mediante la macro \textbf{LOOP}.

\section{Procesamiento de Listas}
Las listas juegan un papel importante en Lisp por razones históricas y prácticas. Históricamente, las listas eran el tipo compuesto original de Lisp. Actualmente un programador de Common Lisp en muchos casos probablemente use un vector, una hash-table o algún tipo definido por el usuario en vez de usar una lista.
%
%\subsection{¡No existen las listas!}
La clave para entender las listas es entender que son realmente una ilusión construida sobre objetos que son instancias de un tipo de datos más primitivo.

\textbf{CONS} (de \"{}construct\"{}, construcción) toma dos argumentos y retorna una nueva celda cons conteniendo los dos valores. Estos valores pueden ser referencias a cualquier tipo de objeto. A menos que el segundo valor sea \textbf{NIL} u otra celda cons, un cons es impreso como los dos valores entre paréntesis separados por un punto, que se nombran dotted-pair.

\begin{verbatim}
(cons 1 2)                        ; (1 . 2)
\end{verbatim}

Los dos valores en una celda cons son llamados el \textbf{CAR} y el \textbf{CDR} de una celda, debido a las instrucciones de la computadora con la que se accedían (Contents of Address part of Register number, Contents of Decrement part of Register number):

\begin{verbatim}
(car (cons 1 2))                  ; 1
(cdr (cons 1 2))                  ; 2
\end{verbatim}

Ambos (\textbf{CAR} y \textbf{CDR}) son también lugares que puede ser seteados por \textbf{SETF}; dada una celda cons existente, es posible asignar un nuevo valor a cualquiera de sus valores.

\begin{verbatim}
(defparameter *cons* (cons 1 2))  ; *cons* es (1 . 2)
(setf (car *cons*) 10)            ; *cons* es (10 . 2)
(setf (cdr *cons*) 20)            ; *cons* es (10 . 20)
\end{verbatim}

Como los valores en una celda cons pueden ser referencias a cualquier tipo de objeto, se pueden construir estructuras mas grandes enlazando celdas cons entre si. Las listas están construidas de esta forma, enlazando celdas cons en una cadena. Los elementos de la lista estan guardados en el \textbf{CAR} de la celda mientras que en \textbf{CDR} contiene la referencia a la siguiente celda cons. La última celda en la cadena tiene un \textbf{NIL} como valor en su \textbf{CDR}.

Entonces cuando se dice que un valor en particular es una lista, lo que realmente se está diciendo es que el valor es \textbf{NIL} o es una referencia a una celda cons. El car de la celda es el primer elemento de la lista, y el cdr es una referencia a otra lista, que es otra celda cons o \textbf{NIL}, conteniendo los elementos restantes. El printer de Lisp entiende esta convención e imprime las cadenas de celdas cons como listas entre paréntesis en vez de sus dotted-pairs.

\begin{verbatim}
(cons 1 nil)                      ; (1)
(cons 1 (cons 2 nil))             ; (1 2)
(cons 1 (cons 2 (cons 3 nil)))    ; (1 2 3)
\end{verbatim}
%\newpage
%Cuando hablamos sobre estructuras construidas sobre celdas, algunos diagramas pueden ser de gran ayuda.

%\begin{figure}[htb]
%  \includegraphics[width=0.4\textwidth]{celda}
%  \label{fig:celda}
%\end{figure}

%La caja a la izquierda representa el CAR, y la caja de la derecha representa el CDR. Por ejemplo, la lista (A B C), que consiste de tres %celdas cons linkeadas por sus CDRs, se diagramaría de esta forma:

%\begin{figure}[htb]
%  \includegraphics[width=0.4\textwidth]{ejemploCelda}
%  \label{fig:celda}
%\end{figure}

Aún así, no se necesitan manejar las celdas cons individualmente; hay funciones estándar dedicadas a manipular listas. Una de ellas es \textbf{LIST}, que toma sus parámetros y arma las celdas cons correspondientes a una lista:

\begin{verbatim}
(list 1)                          ; (1)
(list 1 2)                        ; (1 2)
(list 1 2 3)                      ; (1 2 3)
\end{verbatim}

Para tomar la primera parte y el resto de una lista, están las funciones \textbf{FIRST} y \textbf{REST} respectivamente, sinonímicas con \textbf{CAR} y \textbf{CDR} pero con nombres más apropiados para manejo de listas:

\begin{verbatim}
(defparameter *list* (list 1 2))  ; *list* es (1 2)
(setf (first *list*) 10)          ; *list* es (10 2)
(setf (rest *list*) (list 20 30)) ; *list* es (10 20 30)
\end{verbatim}

\section{Macros}
Todos los programadores deberían estar familiarizados con la idea de que un lenguaje puede incluir una librería estandar de funcionalidad que está implementeda en terminos  de un lenguaje núcleo. Si C no tuviese una función que haga algo, se puede escribir y tener una versión un poco más completa de C. Similarmente, en un lenguaje como Java o Smalltalk donde la mayoría de las partes interesantes del lenguaje están definidas en términos de clases, definiendo nuevas clases se extiende el lenguaje, haciéndolo un mejor lenguaje para expresar lo que se trata de hacer.

Mientras Common Lisp soporta ambos métodos de extensión del lenguaje, las macros le dan a Common Lisp todavía otra manera. Cada macro define su propia sintaxis, determinando cómo las S-expressions son cambiadas a forms de Lisp válidos.

Con las macros como parte del lenguaje es posible construir tanto nuevas sintaxis de control como \textbf{WHEN}, \textbf{DOLIST} y \textbf{LOOP} como formas de definicion tales como \textbf{DEFUN} y \textbf{DEFPARAMETER} como parte de la librería estandar.
 
El loop de ejecución de un macro es un poco distinto al REPL, modificandose de ésta forma:
\begin{enumerate}{}{}
	\item Reader
	\item Procesamiento de macros
	\item Evaluator
	\item Printer
\end{enumerate}

Ejemplo

\begin{verbatim}
(backwards ("Hello, World!" t format)) 
\end{verbatim}
\begin{verbatim}
Hello, World!
\end{verbatim}
\begin{verbatim}
NIL
\end{verbatim}

Se puede ver que la expresión escrita arriba no sería código Lisp válido y de ser evaluada directamente por el evaluator antes de pasar por el macro produciría un error en tiempo de ejecución. Sin embargo, gracias a la ejecución del loop por parte del macro antes descripto, el código más arriba es código Lisp válido.

\begin{verbatim}
(defmacro backwards (expr) (reverse expr))
\end{verbatim}

Un ejemplo más útil sería poder usar un operador condicional en el cual se pueda ejecutar más de una sentencia si se cumple una condición, ya que \textbf{IF} sólo acepta una. Éste caso ya está implementado en el lenguaje como la sentencia \textbf{WHEN}, pero puede reimplementarse fácilmente con macros. Por ejemplo, se quiere pintar una casa de rojo y mover una vaca un paso hacia arriba si el pato es azul.

Si se tuviera éste caso:
\begin{verbatim}
(if (eql (colour the-duck) :blue)
  (paint the-house :red)
  (step-move the-cow :up))
\end{verbatim}
Sólo se pintaría la casa de rojo si el pato fuera azul, y no se movería la vaca.

Se puede usar el operador \textbf{PROGN} para usar un número arbitrario de expresiones, pero se tendría una sentencia tediosa de repetir:
\begin{verbatim}
(if (eql (colour the-duck) :blue)
  (progn
    (paint the-house :red)
    (step-move the-cow :up)))
\end{verbatim}

Se puede automatizar un poco el proceso con una macro que tome un número arbitrario de expresiones y las encierre en un \textbf{PROGN} de forma tal que la sentencia anterior se pueda reescribir de una forma más concisa:
\begin{verbatim}
(when (eql (colour the-duck) :blue)
  (paint the-house :red)
  (step-move the-cow :up))
\end{verbatim}

Una solución posible es la siguiente:
\begin{verbatim}
(defmacro when (condition &rest body)
  `(if ,condition (progn ,@body)))
\end{verbatim}

\section{Programación orientada a objetos}
A pesar de que Lisp originalmente fue concebido como un lenguaje procedural y funcional, uno de las características que fue adquiriendo a lo largo de los años y que se formalizó en Common Lisp es su fuerte soporte para programación orientada a objetos. Los lenguajes en los que está basado datan de cuando la programación orientada a objetos estaba siendo profundamente investigada, y los conceptos que CLOS al incluirse en el estándar formalizó demasiados conceptos como para explicar en un resúmen. Se procurará a continuación ver los conceptos más esenciales, sin analizar en detalle problemas de herencia múltiple y cómo son resueltos por CLOS.

\subsection{Métodos}
Lisp sigue un patrón diferente al establecido por Simula y seguido por la mayoría de los lenguajes orientados a objetos, incluyendo originalmente a Lisp, en el cual cada método se invoca para un objeto en particular. En el patrón que terminó fijándose en los lenguajes Lisp modernos, los métodos son funciones sin ligar a ningún objeto en particular. Ésto simplifica mucho aspectos sintácticos de llamadas a métodos, y abre las posibilidades a características que directamente carecen de sentido en sistemas de objetos de pasado de mensajes.
\subsubsection{Funciones genéricas}
Para unificar métodos con funciones, en Lisp hay un tipo de funciones llamadas funciones genéricas. Éstas definen operaciones abstractas, especificando un nombre y una lista de parámetros, pero sin implementación:
\begin{verbatim}
(defgeneric paint (thing which-colour))
\end{verbatim}
\subsubsection{Métodos}
Para poder hacer algo con una función genérica, se tiene que implementar; ésto se hace por medio de métodos. Cada método provee una implementación de la función genérica para clases particulares de argumentos. Una de las diferencias más grandes de Lisp con otras familias de lenguajes es que en vez de pertenecer a las clases, cada método pertenece a su función genérica, la cual es responsable de qué métodos ejecutar en qué invocación.
Los métodos indican qué tipos de argumentos pueden manejar especializando los parámetros definidos en la función genérica:
\begin{verbatim}
(defmethod paint ((thing house) which-colour)
  (call-over *contractors*)
  (apply-colour thing which-colour))
(defmethod paint ((thing badger) which-colour)
  (stalk thing)
  (hold-down thing)
  (apply-colour thing which-colour)
  (fly-away))
\end{verbatim}
Se puede apreciar que \textbf{DEFMETHOD} se usa en forma similar a \textbf{DEFUN} salvo por la diferencia de que al definir un método se pueden especializar sus argumentos. Aunque es la forma más usual, no es obligatorio que los nombres de los parámetros sigan los usados en la función genérica.

\subsubsection{Multimétodos}
Los multimétodos son métodos que especializan más de un argumento de la función genérica. Éstos son útiles, por ejemplo, en situaciones cuando en lenguajes con pasado de mensajes no es claro en cual de varios objetos definir un método que los relacionados:
\begin{verbatim}
(defgeneric beat (drum stick))
(defmethod beat ((drum taiko) (stick mallet)
  "Boom")
(defmethod beat ((drum taiko) (stick badger))
  "Hiss")
(defmethod beat ((drum stone) (stick mallet))
  "Bam")
(defmethod beat ((drum stone) (stick badger))
  "Growl")
\end{verbatim}
Nótese que, aunque igual se tienen que definir todos los métodos correspondientes, no es no es necesario escribir código de dispatching.

\subsection{Clases}
Las clases son los diferentes tipos de objetos. Como en Smalltalk, todas las clases están organizados en un árbol de jerarquías, que en el caso de Lisp está enraizada en la clase \textbf{T}. Las clases que representan muchos de los tipos de datos nativos de Lisp como \textbf{INTEGER}, \textbf{STRING} y \textbf{LIST} tienen su propia sección de la jerarquía de clases, y están manipuladas por funciones como las ya vistas. No se puede heredar de ellas, pero se puede extender su comportamiento con métodos que se especialicen en ellas. Para definir clases de usuario, está disponible la clase \textbf{STANDARD-OBJECT}, de la cual heredan automáticamente todas las clases de usuario si no se especificó ninguna otra. Generalmente, las clases de usuario tienen metaclase \textbf{STANDARD-CLASS}. Otra sección de la jerarquía está disponible para las condiciones, pero eso se verá más tarde.

Para definir una clase de usuario, se usa la sentencia \textbf{DEFCLASS}, con una lista de superclases y una lista de slots, o atributos, que pueden ser vacías, y para crear una instancia de clase de usuario se usa la sentencia \textbf{MAKE-INSTANCE} con un símbolo de clase:
\begin{verbatim}
(defclass animal () (name weight colour))
(defclass badger (animal) ())
(defclass beaver (animal) (tail))
(defclass duck (animal) (beak))
(defclass platypus (beaver duck) ())
(defparameter *perry* (make-instance 'platypus))
\end{verbatim}

\subsubsection{Inicialización}
Para acceder a los slots de un objeto se usa la función \textbf{SLOT-VALUE}, pero no se puede usar el valor si no está definido. Para definirlo se puede usar \textbf{SETF}:
\begin{verbatim}
(setf (slot-value *perry* 'name) "Perry")
(princ (slot-value *perry* 'name))
\end{verbatim}

Se pueden inicializar los valores de los slots automáticamente de dos formas. Una de ellas es definiendo un método \textbf{INITIALIZE-INSTANCE}, llamado automáticamente por \textbf{MAKE-INSTANCE}. Generalmente va a ser llamado al crear instancias de la clase para la que está definido y clases hijas de ella. Otra forma es especificando ciertas opciones en la lista de slots de las definiciones de clase; para eso se pueden usar las opciones \textbf{:initarg}, que especifica qué opción se puede pasar a \textbf{MAKE-INSTANCE} para inicializarlo, e \textbf{:initform}, que le da un valor al slot si no fue inicializado en \textbf{MAKE-INSTANCE}. Ninguno es obligatorio y pueden usarse independientemente, y para asegurar que en una instancia un determinado slot sea inicializado se puede señalar un arror:
\begin{verbatim}
(defclass animal ()
  ((name
    :initarg :name
    :initform (error "Must supply name"))
   (weight
    :initarg :weight
    :initform 1)
   (colour
    :initarg :colour
    :initform :brown)))
(defparameter *joe*
  (make-instance 'badger
    :name "Joe"
    :colour :chocolate))
\end{verbatim}

\subsubsection{Accessors}
Aunque con \textbf{MAKE-INSTANCE} y \textbf{SLOT-VALUE} se tiene todo lo necesario para manipular instancias de clase, acceder directamente a los slots puede llevar a código frágil, por ejemplo si se cambia cómo está representado internamente un atributo. Para proveer formas estables de acceder a las propiedades de un objeto, se pueden crear funciones dedicadas:
\begin{verbatim}
(defgeneric name (thing))
(defmethod name ((thing animal))
  (slot-value thing 'name))
(defgeneric (setf name) (newname thing))
(defmethod (setf name) (newname (thing animal))
  (setf (slot-value thing 'name) newname))
(setf (name *joe*) "Joe the Badger")
(princ (name *joe*))
\end{verbatim}

Aunque éstas funciones son simples de definir, su repetición para cada atributo para cada clase es tedioso cuando son atributos simples; se pueden simplificar con las opciones \textbf{:reader}, \textbf{writer} y \textbf{:accessor}. \textbf{:reader} crea una función genérica, si es necesario, y un método con el nombre de su argumento, que devuelve el contenido del slot. \textbf{:writer} recibe un nombre de una función \textbf{SETF} y lo usa para crear una función genérica y método para asignar un valor al slot; así, la definición del nombre de animal del ejemplo podría quedar así:
\begin{verbatim}
(name
  :initarg :name
  :initform (error "Must supply name")
  :reader name
  :writer (setf name))
\end{verbatim}

Como se suelen definir juntos lectores y escritores, \textbf{:accessor} crea funciones lectoras y escritoras:
\begin{verbatim}
(name
  :initarg :name
  :initform (error "Must supply name")
  :accessor name)
\end{verbatim}

Otra opción para slots es \textbf{:documentation}, que puede recibir un string que documente el propósito del slot. Poniendo todo junto, la definición de la clase del ejemplo quedaría así:
\begin{verbatim}
(defclass animal ()
  ((name
    :initarg :name
    :initform (error "Must supply name")
    :accessor name
    :documentation "Animal's name")
   (weight
    :initarg :weight
    :initform 1
    :accessor weight
    :documentation "Animal's weight")
   (colour
    :initarg :colour
    :initform :brown
    :reader colour
    :documentation "Animal's coat colour")))
\end{verbatim}

\subsubsection{Atributos de clase}
Aunque CLOS tiene soporte para atributos de clase, éstos son usados como recursos compartidos. Se accede a ellos con \textbf{SLOT-VALUE} o accessors sobre instancias existentes, por lo cual no son completamente equivalentes a atributos estáticos de clase en C++ o Java. Para especificar que un atributo es de clase o de instancia, se usa la opción \textbf{:allocation}, que puede recibir como argumento \textbf{:instance} o \textbf{:class}, siendo \textbf{:instance} el valor por defecto si no se usa \textbf{:allocation}. Si hay un \textbf{:initform} declarado para un atributo de clase, se evalúa sólo cuando se define la clase, mientras que si está definido un \textbf{:initarg} se evalúa cada vez que se crea una instancia de la clase, cambiando el valor que ven todas las instancias de clase en ése slot.

\section{Condiciones}
En sistemas reales, existen muchas situaciones extraordinarias que normalmente implican un estado en el que el no está garantizado que el programa opera como se debe. Si se espera abrir un archivo puede no existir, puede caerse una conexión de red o puede estar mal formada una entrada. Muchos lenguajes modernos tienen mecanismos para lidiar con esos casos; frecuentemente se llaman excepciones.

En Common Lisp se tiene el mecanismo de condiciones. Éstas permiten no sólo informar y manejar situaciones extraordinarias sino también proveer distintas formas de lidiar con cada condición, que pueden ser elegidas más "afuera" en el stack.

\subsection{Creando condiciones}
Como en otros lenguajes, las condiciones están representadas por objetos. En el caso de Common Lisp, heredan de \textbf{CONDITION} en vez de \textbf{STANDARD-OBJECT}, y también pueden tener slots y métodos, pero hay algunas limitaciones; no se puede acceder a los slots de una condición con \textbf{SLOT-VALUE}, debiendo definirse accesores para usarlos, y aunque se pueden inicializar con \textbf{MAKE CONDITION} en vez de \textbf{MAKE-INSTANCE}, no se puede proveer un constructor como en clases se puede con \textbf{INITIALIZE-INSTANCE}. Para definir una clase de condición se usa la macro \textbf{DEFINE-CONDITION}, y para crear una condición de error generalmente se la hace heredar de la clase \textbf{ERROR}, que es subclase de \textbf{CONDITION}:

\begin{verbatim}
(define-condition malformed-animal-name-error (error)
  ((subject :initarg :subject :reader subject)))
\end{verbatim}

Para señalar una condición, se usa la función \textbf{ERROR}, que internamente usa la función \textbf{SIGNAL}. Se puede usar o con el nombre de la condición y las opciones de inicialización, o con una instancia de condición. La primera opción suele usarse ni bien se detecta una condición, y la segunda para reseñalar una condición existente:
\begin{verbatim}
(defun check-pet-name (pet)
  (if (= (length (name pet)) 0)
    (error 'malformed-animal-name-error
      :subject pet)
    (name pet)))
\end{verbatim}

\subsection{Manejando condiciones}
Cuando se señala un error, el mecanismo de condiciones busca la forma de manejarlo más cercana en el stack a donde se señaló la condición, y si no encuentra ninguna, va al debugger. Para evitar ésta situación, se debe establecer un condition handler. Si hay varios definidos en el stack, se usa el que esté más adentro y que pueda manejar una condición de ese tipo. Cuando encuentra un handler útil, llama el bloque correspondiente pasándole el objeto de la condición. Para crear un condition handler se usa la macro \textbf{HANDLE-CASE}, la cual recibe una expresión que pueda señalar una condición, y una o más (puede no ser ninguna pero carece de sentido) listas con el tipo de condición, una lista con un nombre de variable para proveer la excepción (puede ser la lista vacía si no se necesita), y el código que se debe correr para esa condición.

\begin{verbatim}
(defun pet-census (pets)
  (loop for pet in pets
    for name = (handler-case (check-pet-name pet)
                 (malformed-animal-name-error (e) nil))
    when name collect it)))
\end{verbatim}

\subsection{Restarts}
El sistema de condiciones permite proveer diferentes soluciones a un problema separando el manejo de errores en dos partes; se puede poner el código que recupera de condiciones de error en restarts, y pueden ser invocados por condition handlers para manejar el error de diferentes formas en cada situación. Cuando se llama un restart, sea desde el debugger o desde el código, se recorre el stack hacia adentro de nuevo hasta encontrar un restart con el nombre correcto. Para proveer restarts  sepuede usar la macro \textbf{RESTART-CASE}, con la diferencia de que los nombres de los restarts son simplemente nombres y no necesariamente el nombre de alguna clase de error, y pueden tener más de un argumento. Para aprovechar la interacción con el debugger, hay dos opciones \textbf{:report} e \textbf{:interactive}, las cuales respectivamente especifican un string a mostar y una función o lambda-expression a correr si se llega al debugger. Ésta función debe retornar una lista, que es usada para llenar los argumentos de la llamada al restart:

\begin{verbatim}
(defun pet-census (pets)
  (loop for pet in pets
    for name = (restart-case (check-pet-name pet)
                 (ignore ()
                   :report "Ignore pet"
                   nil)
                 (use-value (new-name)
                   :report "Use filler value without renaming pet"
                   :interactive (lambda () (list (read-line)))
                   new-name)
                 (rename (new-name)
                   :report "Specify new pet name"
                   :interactive (lambda () (list (read-line)))
                   (setf (name pet) new-name)
                   (check-pet-name pet)))
    when name collect it)))
\end{verbatim}

Para invocar un restart se puede usar la función \textbf{INVOKE-RESTART} con el restart a invocar, pero falla si el restart no existe. Para fijarse si un restart existe se usa la función \textbf{FIND-RESTART} con el nombre del restart; devuelve el objeto del restart si existe y \textbf{NIL} si no.

\begin{verbatim}
(defun ignore-pet-name (c)
  (let ((restart (find-restart 'ignore)))
    (when restart (invoke-restart restart))))
\end{verbatim}

Hay casos en los que todas las condiciones de cierto tipo son tratadas de la misma manera. En esos casos, se pueden enlazar a acciones, pero no se puede usar \textbf{HANDLER-CASE} ya que ya se deshizo el stack cuando se llega al \textbf{HANDLER-CASE}. así, se debe usar la macro \textbf{HANDLER-BIND}. Ésta recibe una lista de bindings y el código a proteger, y cada uno de esos bindings es una lista formada por el nombre de la condición a tratar y un objeto de función o lambda expression que recibe un parámetro con la condición.

\begin{verbatim}
(handler-bind ((malformed-animal-name-error #'ignore-pet-name))
  (pet-census (list
    (make-instance 'platypus :name "Perry")
    (make-instance 'badger :name "Joe")
    (make-instance 'duck :name ""))))
\end{verbatim}

%\section{Conclusión} "Y ésto con qué se come?", punteros a por donde seguir
\appendix
\section{Ejemplos}
Archivos adjuntos:
\begin{itemize}
	\item N reinas \attachfile[mimetype=text/x-script.lisp, description=Archivo fuente de la solución del problema de las n reinas]{nreinas.lisp}
	\item Base de datos \attachfile[mimetype=text/x-script.lisp, description=Archivo fuente de ejemplo de base de datos]{db.lisp}
\end{itemize}
% Ejemplo de clases y condiciones con los animales? playground.lisp?

\end{document}
